﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Collections;
using Encriptador_DES_CFB.logica;

namespace Encriptador_DES_CFB
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            this.Loaded += new RoutedEventHandler(MainWindow_Loaded);
        }

        void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            string entrada = "Hola como estás? Espero que bien :D";
            string[] trozos = ProcesarTexto.Procesar(entrada);
            BitArray[] retazos = ProcesarTexto.Transformar(trozos);
            string clave = "Encripta";
            BitArray[] final = AlgoritmoCFB.CFB_Encriptar(retazos, clave);
            BitArray[] termino = AlgoritmoCFB.CFB_Desencriptar(final, clave);
            String resultado = "";

            for (int i = 0; i < termino.Length; i++)
            {
                resultado =  resultado + TransformarABinario.ToByteArray(termino[i]);
            }

            Console.WriteLine(resultado);
            //char[] ent = new char[entrada.Length];
            //int trozos = entrada.Length / 8;
            //ent = entrada.ToCharArray();
            //double largo = entrada.Length;
            //double cant = Math.Ceiling(largo / 8);
            //char[] aux = new char[8];
            //int valor = int.Parse(cant.ToString());
            //string[] resultante = new string[valor];


            //for (int i = 0; i < valor; i++)
            //{                
            //    if ((8 * i + 8) < entrada.Length)
            //        resultante[i] = entrada.Substring(8 * i, 8);
            //    else
            //        resultante[i] = entrada.Substring(8 * i, (entrada.Length - 8 * i));  
            //}

            //Console.WriteLine("el largo de la entrada es :" + largo + " y la cantidad de espacio que usara es: " + cant + " y el primer pedazo es :" + resultante[valor-1]);


            //BitArray[] claves = generarClave.generarClaves("Encripta");
            //BitArray des = Encriptacion.Encriptar("Cifrado", claves);
            //Desescriptacion.Desencriptar(des, claves);
            
        }

        //public static BitArray[] generarClave(string claveInic)
        //{
        //    BitArray[] clave = new BitArray[16];//tendrá las 16 claves
        //    BitArray claveBin = TransformarABinario.transformarABinario(claveInic);
            
        //    BitArray res = EliminarBit.eliminarBit(claveBin);
        //    BitArray per = Permutar.permutar(res, Cajas.Caja1);//error!!!!!
            
        //    BitArray[] res2 = Dividir.dividir(per, 2);

        //    BitArray[] total = new BitArray[2];
        //    total[0] = Rotar.rotarBit(res2[0], Cajas.Rondas, 0);
        //    total[1] = Rotar.rotarBit(res2[1], Cajas.Rondas, 0);
        //    BitArray conc = Concatenar.concatenar(total);             
        //    clave[0] = Permutar.permutarBien(conc, Cajas.Caja2);//Primera clave :D
        //    //IO.ImprimeBitArray(clave[0], 6);
        //    //Console.WriteLine("primera iteracion");
        //    //IO.ImprimeBitArray(clave[0], 6);

        //    BitArray[] total1 = new BitArray[2];
        //    total1[0] = Rotar.rotarBit(total[0], Cajas.Rondas, 1);
        //    total1[1] = Rotar.rotarBit(total[1], Cajas.Rondas, 1);
        //    BitArray conc2 = Concatenar.concatenar(total1);
        //    clave[1] = Permutar.permutarBien(conc2, Cajas.Caja2);//segunda clave :D

        //    //Console.WriteLine("segunda iteracion");
        //    //IO.ImprimeBitArray(clave[1], 6);

        //    BitArray[] total2 = new BitArray[2];
        //    total2[0] = Rotar.rotarBit(total1[0], Cajas.Rondas, 2);
        //    total2[1] = Rotar.rotarBit(total1[1], Cajas.Rondas, 2);
        //    BitArray conc3 = Concatenar.concatenar(total2);
        //    clave[2] = Permutar.permutarBien(conc3, Cajas.Caja2);//tercera clave :D

        //    //Console.WriteLine("tercera iteracion");
        //    //IO.ImprimeBitArray(clave[2], 6);

        //    BitArray[] total3 = new BitArray[2];
        //    total3[0] = Rotar.rotarBit(total2[0], Cajas.Rondas, 3);
        //    total3[1] = Rotar.rotarBit(total2[1], Cajas.Rondas, 3);
        //    BitArray conc4 = Concatenar.concatenar(total3);
        //    clave[3] = Permutar.permutarBien(conc4, Cajas.Caja2);//cuarta clave :D

        //    //Console.WriteLine("cuarta iteracion");
        //    //IO.ImprimeBitArray(clave[3], 6);

        //    BitArray[] total4 = new BitArray[2];
        //    total4[0] = Rotar.rotarBit(total3[0], Cajas.Rondas, 4);
        //    total4[1] = Rotar.rotarBit(total3[1], Cajas.Rondas, 4);
        //    BitArray conc5 = Concatenar.concatenar(total4);
        //    clave[4] = Permutar.permutarBien(conc5, Cajas.Caja2);//quinta clave :D

        //    //Console.WriteLine("quinta iteracion");
        //    //IO.ImprimeBitArray(clave[4], 6);

        //    BitArray[] total5 = new BitArray[2];
        //    total5[0] = Rotar.rotarBit(total4[0], Cajas.Rondas, 5);
        //    total5[1] = Rotar.rotarBit(total4[1], Cajas.Rondas, 5);
        //    BitArray conc6 = Concatenar.concatenar(total5);
        //    clave[5] = Permutar.permutarBien(conc6, Cajas.Caja2);//sexta clave :D

        //    //Console.WriteLine("sexta iteracion");
        //    //IO.ImprimeBitArray(clave[5], 6);

        //    BitArray[] total6 = new BitArray[2];
        //    total6[0] = Rotar.rotarBit(total5[0], Cajas.Rondas, 6);
        //    total6[1] = Rotar.rotarBit(total5[1], Cajas.Rondas, 6);
        //    BitArray conc7 = Concatenar.concatenar(total6);
        //    clave[6] = Permutar.permutarBien(conc7, Cajas.Caja2);//sexta clave :D

        //    //Console.WriteLine("septima iteracion");
        //    //IO.ImprimeBitArray(clave[6], 6);

        //    BitArray[] total7 = new BitArray[2];
        //    total7[0] = Rotar.rotarBit(total6[0], Cajas.Rondas, 7);
        //    total7[1] = Rotar.rotarBit(total6[1], Cajas.Rondas, 7);
        //    BitArray conc8 = Concatenar.concatenar(total7);
        //    clave[7] = Permutar.permutarBien(conc8, Cajas.Caja2);//sexta clave :D

        //    //Console.WriteLine("octava iteracion");
        //    //IO.ImprimeBitArray(clave[7], 6);

        //    BitArray[] total8 = new BitArray[2];
        //    total8[0] = Rotar.rotarBit(total7[0], Cajas.Rondas, 8);
        //    total8[1] = Rotar.rotarBit(total7[1], Cajas.Rondas, 8);
        //    BitArray conc9 = Concatenar.concatenar(total8);
        //    clave[8] = Permutar.permutarBien(conc9, Cajas.Caja2);//sexta clave :D

        //    //Console.WriteLine("novena iteracion");
        //    //IO.ImprimeBitArray(clave[8], 6);

        //    BitArray[] total9 = new BitArray[2];
        //    total9[0] = Rotar.rotarBit(total8[0], Cajas.Rondas, 9);
        //    total9[1] = Rotar.rotarBit(total8[1], Cajas.Rondas, 9);
        //    BitArray conc10 = Concatenar.concatenar(total9);
        //    clave[9] = Permutar.permutarBien(conc10, Cajas.Caja2);//sexta clave :D

        //    //Console.WriteLine("decima iteracion");
        //    //IO.ImprimeBitArray(clave[9], 6);

        //    BitArray[] total10 = new BitArray[2];
        //    total10[0] = Rotar.rotarBit(total9[0], Cajas.Rondas, 10);
        //    total10[1] = Rotar.rotarBit(total9[1], Cajas.Rondas, 10);
        //    BitArray conc11 = Concatenar.concatenar(total10);
        //    clave[10] = Permutar.permutarBien(conc11, Cajas.Caja2);//sexta clave :D

        //    //Console.WriteLine("onceava iteracion");
        //    //IO.ImprimeBitArray(clave[10], 6);

        //    BitArray[] total11 = new BitArray[2];
        //    total11[0] = Rotar.rotarBit(total10[0], Cajas.Rondas, 11);
        //    total11[1] = Rotar.rotarBit(total10[1], Cajas.Rondas, 11);
        //    BitArray conc12 = Concatenar.concatenar(total11);
        //    clave[11] = Permutar.permutarBien(conc12, Cajas.Caja2);//sexta clave :D

        //    //Console.WriteLine("doceava iteracion");
        //    //IO.ImprimeBitArray(clave[11], 6);

        //    BitArray[] total12 = new BitArray[2];
        //    total12[0] = Rotar.rotarBit(total11[0], Cajas.Rondas, 12);
        //    total12[1] = Rotar.rotarBit(total11[1], Cajas.Rondas, 12);
        //    BitArray conc13 = Concatenar.concatenar(total12);
        //    clave[12] = Permutar.permutarBien(conc13, Cajas.Caja2);//sexta clave :D

        //    //Console.WriteLine("decima tercera iteracion");
        //    //IO.ImprimeBitArray(clave[12], 6);

        //    BitArray[] total13 = new BitArray[2];
        //    total13[0] = Rotar.rotarBit(total12[0], Cajas.Rondas, 13);
        //    total13[1] = Rotar.rotarBit(total12[1], Cajas.Rondas, 13);
        //    BitArray conc14 = Concatenar.concatenar(total13);
        //    clave[13] = Permutar.permutarBien(conc14, Cajas.Caja2);//sexta clave :D

        //    //Console.WriteLine("decima cuarta iteracion");
        //    //IO.ImprimeBitArray(clave[13], 6);

        //    BitArray[] total14 = new BitArray[2];
        //    total14[0] = Rotar.rotarBit(total13[0], Cajas.Rondas, 14);
        //    total14[1] = Rotar.rotarBit(total13[1], Cajas.Rondas, 14);
        //    BitArray conc15 = Concatenar.concatenar(total14);
        //    clave[14] = Permutar.permutarBien(conc15, Cajas.Caja2);//sexta clave :D

        //    //Console.WriteLine("decima quinta iteracion");
        //    //IO.ImprimeBitArray(clave[14], 6);

        //    BitArray[] total15 = new BitArray[2];
        //    total15[0] = Rotar.rotarBit(total14[0], Cajas.Rondas, 15);
        //    total15[1] = Rotar.rotarBit(total14[1], Cajas.Rondas, 15);
        //    BitArray conc16 = Concatenar.concatenar(total15);
        //    clave[15] = Permutar.permutarBien(conc16, Cajas.Caja2);//sexta clave :D

        //    //Console.WriteLine("decima sexta iteracion");
        //    //IO.ImprimeBitArray(clave[15], 6);

        //    return clave;
        //    //int q = 0;
            
        //    //BitArray[] total1 = new BitArray[2];
        //    //BitArray[] total2 = new BitArray[2];

        //    //for (int j = 1; j < 16; j++ )
        //    //{

        //    //    if (j - 1 == 0)
        //    //    {
        //    //        total1[0] = total[0];
        //    //        total1[1] = total[1];
        //    //    }
        //    //    else
        //    //    {
        //    //        total1[0] = total2[0];
        //    //        total1[1] = total2[1];
        //    //    }

        //    //    if (j < 16)
        //    //    {
        //    //        //BitArray[] total2 = new BitArray[2];
        //    //        total2[0] = Rotar.rotarBit(total1[0], Cajas.Rondas, j);
        //    //        total2[1] = Rotar.rotarBit(total1[1], Cajas.Rondas, j);
        //    //        BitArray conc1 = new BitArray(48);
        //    //        conc1 = Concatenar.concatenar(total2);
        //    //        clave[j] = Permutar.permutarBien(conc1, Cajas.Caja2);
        //    //        Console.WriteLine("iteracion numero {0}: ", j);
        //    //        IO.ImprimeBitArray(clave[j], 6);
        //    //    }
        //    //    else
        //    //    {
        //    //        q = 1;
        //    //    }
               
        //    //}
        //    //return clave;
        //}

        //BitArray Encriptar(string entrada, BitArray[] claves)
        //{
        //    //throw new NotImplementedException();
        //    BitArray[] salida = new BitArray[2];
        //    BitArray temporal;
        //    BitArray cifradoFinal = new BitArray(64);
        //    BitArray procesar = TransformarABinario.transformarABinario(entrada);
        //    BitArray permu = Permutar.permutarBien(procesar, Cajas.PermInicial);
        //    BitArray[] porciones = Dividir.dividir(permu, 2);
        //    for (int i = 0; i < 16; i++)
        //    {                
        //        salida = ProcesoIter(porciones, claves, i);
        //        if (i < 15) porciones = salida;
        //        else
        //        {
        //            temporal = Concatenar.concatenar(salida);
        //            //IO.ImprimeBitArray(temporal, 32);
        //            //cifradoFinal = Permutar.permutarBien(temporal, Cajas.Permt_Final);
        //            porciones = Dividir.dividir(temporal, 2);
        //            salida[0] = porciones[1];
        //            salida[1] = porciones[0];
        //            cifradoFinal = Concatenar.concatenar(salida);
        //            temporal = Permutar.permutarBien(cifradoFinal, Cajas.Permt_Final);
        //            cifradoFinal = temporal;
        //            //IO.ImprimeBitArray(cifradoFinal, 32);
        //        }
        //    }
        //    return cifradoFinal;
        //}

        //BitArray[] ProcesoIter(BitArray[] entrada, BitArray[] keys, int iteracion)
        //{
        //    BitArray expandida = Permutar.permutarBien(entrada[1], Cajas.expansion);//lado derecho
        //    BitArray xorListo = XOR.xor(expandida, keys[iteracion]);
        //    //IO.ImprimeBitArray(xorListo,6);
        //    BitArray[] pedazos = Dividir.dividir(xorListo, 8);
        //    //IO.ImprimeBitArray(pedazos[0],6);
        //    BitArray f = Concatenar.concatenar(Funcion_S.funcion_s(pedazos));
        //    //IO.ImprimeBitArray(f, 8);
        //    BitArray final = Permutar.permutarBien(f, Cajas.permutacion);
        //    BitArray resultadoXor = XOR.xor(final, entrada[0]);
        //    //IO.ImprimeBitArray(resultadoXor, 8);
        //    BitArray[] retorno = new BitArray[2];
        //    retorno[0] = entrada[1];
        //    retorno[1] = resultadoXor;
        //    return retorno;
        //}

        //BitArray Desencriptar(BitArray entrada, BitArray[] claves)
        //{
        //    //throw new NotImplementedException();
        //    BitArray[] salida = new BitArray[2];
        //    BitArray temporal;
        //    BitArray descifradoFinal = new BitArray(64);
        //    BitArray permu = Permutar.permutarBien(entrada, Cajas.PermInicial);
        //    BitArray[] porciones = Dividir.dividir(permu, 2);
        //    for (int i = 0; i < 16; i++)
        //    {
        //        salida = ProcesoIter(porciones, claves, 15-i);
        //        if (i < 15) porciones = salida;
        //        else
        //        {
        //            temporal = Concatenar.concatenar(salida);
        //            //IO.ImprimeBitArray(temporal, 32);
        //            //cifradoFinal = Permutar.permutarBien(temporal, Cajas.Permt_Final);
        //            porciones = Dividir.dividir(temporal, 2);
        //            salida[0] = porciones[1];
        //            salida[1] = porciones[0];
        //            descifradoFinal = Concatenar.concatenar(salida);
        //            temporal = Permutar.permutarBien(descifradoFinal, Cajas.Permt_Final);
        //            descifradoFinal = temporal;
        //            IO.ImprimeBitArray(descifradoFinal, 8);
        //        }
        //    }
        //    return descifradoFinal;
        //}
    }
}
